using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("InputManager")]
	public class InputManager : MonoBehaviour
	{
		public float m_MouseOverDelay => method_2<float>("m_MouseOverDelay");

		public DragRotatorInfo m_DragRotatorInfo => method_3<DragRotatorInfo>("m_DragRotatorInfo");

		public static float MOBILE_TARGETTING_Y_OFFSET => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "InputManager", "MOBILE_TARGETTING_Y_OFFSET");

		public static float MOBILE_TARGETTING_XY_SCALE => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "InputManager", "MOBILE_TARGETTING_XY_SCALE");

		public ZoneHand m_myHandZone => method_3<ZoneHand>("m_myHandZone");

		public ZonePlay m_myPlayZone => method_3<ZonePlay>("m_myPlayZone");

		public ZoneWeapon m_myWeaponZone => method_3<ZoneWeapon>("m_myWeaponZone");

		public Card m_heldCard => method_3<Card>("m_heldCard");

		public bool m_checkForInput => method_2<bool>("m_checkForInput");

		public GameObject m_lastObjectMousedDown => method_3<GameObject>("m_lastObjectMousedDown");

		public GameObject m_lastObjectRightMousedDown => method_3<GameObject>("m_lastObjectRightMousedDown");

		public Vector3 m_lastMouseDownPosition => method_2<Vector3>("m_lastMouseDownPosition");

		public bool m_leftMouseButtonIsDown => method_2<bool>("m_leftMouseButtonIsDown");

		public bool m_dragging => method_2<bool>("m_dragging");

		public bool m_lastInputDrag => method_2<bool>("m_lastInputDrag");

		public Card m_mousedOverCard => method_3<Card>("m_mousedOverCard");

		public HistoryCard m_mousedOverHistoryCard => method_3<HistoryCard>("m_mousedOverHistoryCard");

		public GameObject m_mousedOverObject => method_3<GameObject>("m_mousedOverObject");

		public float m_mousedOverTimer => method_2<float>("m_mousedOverTimer");

		public ZoneChangeList m_lastZoneChangeList => method_3<ZoneChangeList>("m_lastZoneChangeList");

		public Card m_battlecrySourceCard => method_3<Card>("m_battlecrySourceCard");

		public List<Card> m_cancelingBattlecryCards => method_3<Class271<Card>>("m_cancelingBattlecryCards")?.method_25();

		public bool m_cardWasInsideHandLastFrame => method_2<bool>("m_cardWasInsideHandLastFrame");

		public bool m_isInBattleCryEffect => method_2<bool>("m_isInBattleCryEffect");

		public List<Entity> m_entitiesThatPredictedMana => method_3<Class271<Entity>>("m_entitiesThatPredictedMana")?.method_25();

		public List<Actor> m_mobileTargettingEffectActors => method_3<Class271<Actor>>("m_mobileTargettingEffectActors")?.method_25();

		public Card m_lastPreviewedCard => method_3<Card>("m_lastPreviewedCard");

		public bool m_touchDraggingCard => method_2<bool>("m_touchDraggingCard");

		public bool m_useHandEnlarge => method_2<bool>("m_useHandEnlarge");

		public bool m_hideHandAfterPlayingCard => method_2<bool>("m_hideHandAfterPlayingCard");

		public bool m_targettingHeroPower => method_2<bool>("m_targettingHeroPower");

		public bool m_touchedDownOnSmallHand => method_2<bool>("m_touchedDownOnSmallHand");

		public bool m_enlargeHandAfterDropCard => method_2<bool>("m_enlargeHandAfterDropCard");

		public int m_telemetryNumDragAttacks => method_2<int>("m_telemetryNumDragAttacks");

		public int m_telemetryNumClickAttacks => method_2<int>("m_telemetryNumClickAttacks");

		public bool LeftMouseButtonDown => method_11<bool>("get_LeftMouseButtonDown", Array.Empty<object>());

		public Vector3 LastMouseDownPosition => method_11<Vector3>("get_LastMouseDownPosition", Array.Empty<object>());

		public InputManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public InputManager(IntPtr address)
			: this(address, "InputManager")
		{
		}

		public static InputManager Get()
		{
			return MonoClass.smethod_15<InputManager>(TritonHs.MainAssemblyPath, "", "InputManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public bool IsInputOverCard(Card wantedCard)
		{
			return method_11<bool>("IsInputOverCard", new object[1] { wantedCard });
		}

		public bool ShouldCancelTargeting(bool hitBattlefieldHitbox)
		{
			return method_11<bool>("ShouldCancelTargeting", new object[1] { hitBattlefieldHitbox });
		}

		public void Update()
		{
			method_8("Update");
		}

		public bool HandleKeyboardInput()
		{
			return method_11<bool>("HandleKeyboardInput", Array.Empty<object>());
		}

		public Card GetMousedOverCard()
		{
			return method_14<Card>("GetMousedOverCard", Array.Empty<object>());
		}

		public void SetMousedOverCard(Card card)
		{
			method_8("SetMousedOverCard", card);
		}

		public Card GetBattlecrySourceCard()
		{
			return method_14<Card>("GetBattlecrySourceCard", Array.Empty<object>());
		}

		public void StartWatchingForInput()
		{
			method_8("StartWatchingForInput");
		}

		public void DisableInput()
		{
			method_8("DisableInput");
		}

		public Card GetHeldCard()
		{
			return method_14<Card>("GetHeldCard", Array.Empty<object>());
		}

		public void EnableInput()
		{
			method_8("EnableInput");
		}

		public void OnMulliganEnded()
		{
			method_8("OnMulliganEnded");
		}

		public void SetShouldShowTooltip()
		{
			method_8("SetShouldShowTooltip");
		}

		public ZoneHand GetFriendlyHand()
		{
			return method_14<ZoneHand>("GetFriendlyHand", Array.Empty<object>());
		}

		public bool UseHandEnlarge()
		{
			return method_11<bool>("UseHandEnlarge", Array.Empty<object>());
		}

		public void SetHandEnlarge(bool set)
		{
			method_8("SetHandEnlarge", set);
		}

		public bool DoesHideHandAfterPlayingCard()
		{
			return method_11<bool>("DoesHideHandAfterPlayingCard", Array.Empty<object>());
		}

		public void SetHideHandAfterPlayingCard(bool set)
		{
			method_8("SetHideHandAfterPlayingCard", set);
		}

		public bool DropHeldCard()
		{
			return method_10<bool>("DropHeldCard", new Class276.Enum20[0], Array.Empty<object>());
		}

		public void HandleLeftMouseDown()
		{
			method_8("HandleLeftMouseDown");
		}

		public void ShowPhoneHand()
		{
			method_8("ShowPhoneHand");
		}

		public void HidePhoneHand()
		{
			method_8("HidePhoneHand");
		}

		public void OnHandEnlargeComplete(Zone zone, object userData)
		{
			method_8("OnHandEnlargeComplete", zone, userData);
		}

		public void HidePhoneHandIfOutOfServerPlays()
		{
			method_8("HidePhoneHandIfOutOfServerPlays");
		}

		public bool HasLocalHandPlays()
		{
			return method_11<bool>("HasLocalHandPlays", Array.Empty<object>());
		}

		public void HandleLeftMouseUp()
		{
			method_8("HandleLeftMouseUp");
		}

		public void HandleRightMouseDown()
		{
			method_8("HandleRightMouseDown");
		}

		public void HandleRightMouseUp()
		{
			method_8("HandleRightMouseUp");
		}

		public void HandleRightClick()
		{
			method_8("HandleRightClick");
		}

		public bool CancelOption()
		{
			return method_11<bool>("CancelOption", Array.Empty<object>());
		}

		public bool CancelTargetMode()
		{
			return method_11<bool>("CancelTargetMode", Array.Empty<object>());
		}

		public bool CancelSubOptionMode()
		{
			return method_11<bool>("CancelSubOptionMode", Array.Empty<object>());
		}

		public void PositionHeldCard()
		{
			method_8("PositionHeldCard");
		}

		public int PlayZoneSlotMousedOver(Card card)
		{
			return method_11<int>("PlayZoneSlotMousedOver", new object[1] { card });
		}

		public void HandleUpdateWhileLeftMouseButtonIsDown()
		{
			method_8("HandleUpdateWhileLeftMouseButtonIsDown");
		}

		public void HandleUpdateWhileHoldingCard(bool hitBattlefield)
		{
			method_8("HandleUpdateWhileHoldingCard", hitBattlefield);
		}

		public void ActivatePowerUpSpell(Card card)
		{
			method_8("ActivatePowerUpSpell", card);
		}

		public void ActivatePlaySpell(Card card)
		{
			method_8("ActivatePlaySpell", card);
		}

		public void HandleMouseMove()
		{
			method_8("HandleMouseMove");
		}

		public void HandleUpdateWhileNotHoldingCard()
		{
			method_8("HandleUpdateWhileNotHoldingCard");
		}

		public void HandleMouseOverObjectWhileNotHoldingCard(RaycastHit hitInfo)
		{
			method_8("HandleMouseOverObjectWhileNotHoldingCard", hitInfo);
		}

		public void HandleMouseOff()
		{
			method_8("HandleMouseOff");
		}

		public void HandleMouseOffLastObject()
		{
			method_8("HandleMouseOffLastObject");
		}

		public void GrabCard(GameObject cardObject)
		{
			method_8("GrabCard", cardObject);
		}

		public void DropCanceledHeldCard(Card card)
		{
			method_8("DropCanceledHeldCard", card);
		}

		public void ReturnHeldCardToHand()
		{
			method_8("ReturnHeldCardToHand");
		}

		public bool DropHeldCard(bool wasCancelled)
		{
			return method_10<bool>("DropHeldCard", new Class276.Enum20[1] { Class276.Enum20.Boolean }, new object[1] { wasCancelled });
		}

		public void SendDragDropCancelPlayTelemetry(Entity cancelledEntity)
		{
			method_8("SendDragDropCancelPlayTelemetry", cancelledEntity);
		}

		public void HandleRightClickOnCard(Card card)
		{
			method_8("HandleRightClickOnCard", card);
		}

		public void HandleClickOnCard(GameObject upClickedCard, bool wasMouseDownTarget)
		{
			method_8("HandleClickOnCard", upClickedCard, wasMouseDownTarget);
		}

		public void HandleClickOnCardInBattlefield(Entity clickedEntity)
		{
			method_8("HandleClickOnCardInBattlefield", clickedEntity);
		}

		public void UpdateTelemetryAttackInputCounts(Entity sourceEntity)
		{
			method_8("UpdateTelemetryAttackInputCounts", sourceEntity);
		}

		public void HandleClickOnSubOption(Entity entity, bool isSimulated)
		{
			method_8("HandleClickOnSubOption", entity, isSimulated);
		}

		public void HandleClickOnChoice(Entity entity)
		{
			method_8("HandleClickOnChoice", entity);
		}

		public void ResetBattlecrySourceCard()
		{
			method_8("ResetBattlecrySourceCard");
		}

		public bool IsCancelingBattlecryCard(Card card)
		{
			return method_11<bool>("IsCancelingBattlecryCard", new object[1] { card });
		}

		public void DoEndTurnButton()
		{
			method_8("DoEndTurnButton");
		}

		public void DoEndTurnButton_Option_OnEndTurnRequested()
		{
			method_8("DoEndTurnButton_Option_OnEndTurnRequested");
		}

		public bool DoNetworkResponse(Entity entity, bool checkValidInput)
		{
			return method_11<bool>("DoNetworkResponse", new object[2] { entity, checkValidInput });
		}

		public void OnOptionsReceived(object userData)
		{
			method_8("OnOptionsReceived", userData);
		}

		public void OnCurrentPlayerChanged(Player player, object userData)
		{
			method_8("OnCurrentPlayerChanged", player, userData);
		}

		public void OnOptionRejected(Network.Options.Option option, object userData)
		{
			method_8("OnOptionRejected", option, userData);
		}

		public void OnTurnTimerUpdate(TurnTimerUpdate update, object userData)
		{
			method_8("OnTurnTimerUpdate", update, userData);
		}

		public void OnGameOver(TAG_PLAYSTATE playState, object userData)
		{
			method_8("OnGameOver", playState, userData);
		}

		public void SendGameOverTelemetry()
		{
			method_8("SendGameOverTelemetry");
		}

		public bool DoNetworkChoice(Entity entity)
		{
			return method_11<bool>("DoNetworkChoice", new object[1] { entity });
		}

		public bool DoNetworkOptions(Entity entity)
		{
			return method_11<bool>("DoNetworkOptions", new object[1] { entity });
		}

		public bool DoNetworkSubOptions(Entity entity)
		{
			return method_11<bool>("DoNetworkSubOptions", new object[1] { entity });
		}

		public bool DoNetworkOptionTarget(Entity entity)
		{
			return method_11<bool>("DoNetworkOptionTarget", new object[1] { entity });
		}

		public void EnterOptionTargetMode()
		{
			method_8("EnterOptionTargetMode");
		}

		public void FinishBattlecrySourceCard()
		{
			method_8("FinishBattlecrySourceCard");
		}

		public void ClearBattlecrySourceCard()
		{
			method_8("ClearBattlecrySourceCard");
		}

		public void CancelSubOptions()
		{
			method_8("CancelSubOptions");
		}

		public void FinishSubOptions()
		{
			method_8("FinishSubOptions");
		}

		public void DropSubOptionParentCard()
		{
			method_8("DropSubOptionParentCard");
		}

		public void EndMobileTargetingEffect()
		{
			method_8("EndMobileTargetingEffect");
		}

		public void StartBattleCryEffect(Entity entity)
		{
			method_8("StartBattleCryEffect", entity);
		}

		public void EndBattleCryEffect()
		{
			method_8("EndBattleCryEffect");
		}

		public void ApplyMobileTargettingEffectToActor(Actor actor)
		{
			method_8("ApplyMobileTargettingEffectToActor", actor);
		}

		public void RemoveMobileTargettingEffectFromActor(Actor actor)
		{
			method_8("RemoveMobileTargettingEffectFromActor", actor);
		}

		public bool HandleMulliganHotkeys()
		{
			return method_11<bool>("HandleMulliganHotkeys", Array.Empty<object>());
		}

		public bool HandleUniversalHotkeys()
		{
			return method_11<bool>("HandleUniversalHotkeys", Array.Empty<object>());
		}

		public bool HandleGameHotkeys()
		{
			return method_11<bool>("HandleGameHotkeys", Array.Empty<object>());
		}

		public void ShowBullseyeIfNeeded()
		{
			method_8("ShowBullseyeIfNeeded");
		}

		public bool EntityIsPoisonousForSkullPreview(Entity entity)
		{
			return method_11<bool>("EntityIsPoisonousForSkullPreview", new object[1] { entity });
		}

		public void ShowSkullIfNeeded()
		{
			method_8("ShowSkullIfNeeded");
		}

		public void DisableSkullIfNeeded(Card mousedOverCard)
		{
			method_8("DisableSkullIfNeeded", mousedOverCard);
		}

		public void HandleMouseOverCard(Card card)
		{
			method_8("HandleMouseOverCard", card);
		}

		public void HandleMouseOffCard()
		{
			method_8("HandleMouseOffCard");
		}

		public void HandleMemberClick()
		{
			method_8("HandleMemberClick");
		}

		public bool MouseIsMoving(float tolerance)
		{
			return method_10<bool>("MouseIsMoving", new Class276.Enum20[1] { Class276.Enum20.R4 }, new object[1] { tolerance });
		}

		public bool MouseIsMoving()
		{
			return method_10<bool>("MouseIsMoving", new Class276.Enum20[0], Array.Empty<object>());
		}

		public void ShowTooltipIfNecessary()
		{
			method_8("ShowTooltipIfNecessary");
		}

		public void ShowTooltipZone(GameObject hitObject, TooltipZone tooltip)
		{
			method_8("ShowTooltipZone", hitObject, tooltip);
		}

		public void ShowTooltipInZone(TooltipZone tooltip, string headline, string description)
		{
			method_9("ShowTooltipInZone", new Class276.Enum20[3]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.String
			}, tooltip, headline, description);
		}

		public void ShowTooltipInZone(TooltipZone tooltip, string headline, string description, Vector3 localOffset)
		{
			method_9("ShowTooltipInZone", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.String,
				Class276.Enum20.String,
				Class276.Enum20.ValueType
			}, tooltip, headline, description, localOffset);
		}

		public void HideBigViewCardBacks()
		{
			method_8("HideBigViewCardBacks");
		}

		public void PredictSpentMana(Entity entity)
		{
			method_8("PredictSpentMana", entity);
		}

		public void RollbackSpentMana(Entity entity)
		{
			method_8("RollbackSpentMana", entity);
		}

		public void OnManaCrystalMgrManaSpent()
		{
			method_8("OnManaCrystalMgrManaSpent");
		}

		public bool IsInZone(Entity entity, TAG_ZONE zoneTag)
		{
			return method_10<bool>("IsInZone", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { entity, zoneTag });
		}

		public bool IsInZone(Card card, TAG_ZONE zoneTag)
		{
			return method_10<bool>("IsInZone", new Class276.Enum20[2]
			{
				Class276.Enum20.Class,
				Class276.Enum20.ValueType
			}, new object[2] { card, zoneTag });
		}

		public void SetDragging(bool dragging)
		{
			method_8("SetDragging", dragging);
		}
	}
}
